AmigActive 26/AACD 26.iso/AACD/Magazine/Guru/Samba/source/amiga/amiga.h

C/C++ Source or Header | 2000-05-22 | 11.7 KB | 356 lines

/*
 * $Id: amiga.h 1.7 2000/05/22 19:10:46 olsen Exp olsen $
 *
 * :ts=4
 *
 * AmigaOS wrapper routines for Samba 2.0.0, using the AmiTCP V4 API
 * and the SAS/C V6.58 compiler.
 *
 * Copyright (C) 1999-2000 by Olaf `Olsen' Barthel <[e-mail]>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

/* This file "remaps" library functions to the
 * emulation code in "amiga.c".
 */
#define mkdir(name,mode) amiga_mkdir(name,mode)
int amiga_mkdir(const char *name,int mode);

#define rmdir(name) amiga_rmdir(name)
int amiga_rmdir(const char *name);

#define unlink(name) amiga_unlink(name)
int amiga_unlink(const char *name);

#define creat(name,prot) amiga_creat(name,prot)
int amiga_creat(const char *name,int prot);

#define open(name,mode,prot) amiga_open(name,mode,prot)
int amiga_open(const char *name,int mode,int prot);

#define fopen(name,mode) amiga_fopen(name,mode)
FILE * amiga_fopen(const char *name,const char *mode);

#define rename(old,new) amiga_rename(old,new)
int amiga_rename(const char *old,const char *new);

#define chdir(path) amiga_chdir(path)
int amiga_chdir(const char *path);

#define getcwd(buf,size) amiga_getcwd(buf,size)
char * amiga_getcwd(char *buf,int size);

#define ftruncate(fd,size) amiga_ftruncate(fd,size)
int amiga_ftruncate(int fd,off_t size);

#define accept(sockfd,cliaddr,addrlen) amiga_accept(sockfd,cliaddr,addrlen)
int amiga_accept(int sockfd,struct sockaddr *cliaddr,int *addrlen);

#define bind(sockfd,name,namelen) amiga_bind(sockfd,name,namelen)
int amiga_bind(int sockfd,const struct sockaddr *name,int namelen);

#define close(fh) amiga_close(fh)
int amiga_close(int fh);

#define connect(sockfd,name,namelen) amiga_connect(sockfd,name,namelen)
int amiga_connect(int sockfd,const struct sockaddr *name,int namelen);

#define getpeername(sockfd,name,namelen) amiga_getpeername(sockfd,name,namelen)
int amiga_getpeername(int sockfd,struct sockaddr *name,int *namelen);

#define getsockopt(sockfd,level,optname,optval,optlen) amiga_getsockopt(sockfd,level,optname,optval,optlen)
int amiga_getsockopt(int sockfd,int level,int optname,void *optval,int *optlen);

#define ioctl(fd,request,arg) amiga_ioctl(fd,request,arg)
int amiga_ioctl(int fd,unsigned long request,char *arg);

#define listen(sockfd,backlog) amiga_listen(sockfd,backlog)
int amiga_listen(int sockfd,int backlog);

#define read(fd,data,size) amiga_read(fd,data,size)
int amiga_read(int fd,void *data,unsigned int size);

#define recvfrom(sockfd,buff,len,flags,from,fromlen) amiga_recvfrom(sockfd,buff,len,flags,from,fromlen)
int amiga_recvfrom(int sockfd,void *buff,int len,int flags,struct sockaddr *from,int *fromlen);

#define select(nfds,readfds,writefds,exceptfds,timeout) amiga_select(nfds,readfds,writefds,exceptfds,timeout)
int amiga_select(int nfds,fd_set *readfds,fd_set *writefds,fd_set *exceptfds,struct timeval *timeout);

#define sendto(sockfd,buff,len,flags,to,tolen) amiga_sendto(sockfd,buff,len,flags,to,tolen)
int amiga_sendto(int sockfd,const void *buff,int len,int flags,const struct sockaddr *to,int tolen);

#define setsockopt(sockfd,level,optname,optval,optlen) amiga_setsockopt(sockfd,level,optname,optval,optlen)
int amiga_setsockopt(int sockfd,int level,int optname,const void *optval,int optlen);

#define socket(domain,type,protocol) amiga_socket(domain,type,protocol)
int amiga_socket(int domain,int type,int protocol);

#define write(fd,data,size) amiga_write(fd,data,size)
int amiga_write(int fd,const void *data,unsigned int size);

#define stat(name,st) amiga_stat(name,(struct stat *)st)
int amiga_stat(const char *name, struct stat *st);

#define lstat(name,st) amiga_lstat(name,(struct stat *)st)
int amiga_lstat(const char *name, struct stat *st);

#define fstat(fd,st) amiga_fstat(fd,st)
int amiga_fstat(int fd,struct stat * st);

#define chmod(name,mode) amiga_chmod(name,mode)
int amiga_chmod(const char *name,int mode);

#define dup(fd) amiga_dup(fd)
int amiga_dup(int fd);

#define dup2(old,new) amiga_dup2(old,new)
int amiga_dup2(int old_fd,int new_fd);

#define chown(name,uid,gid) amiga_chown(name,uid,gid)
int amiga_chown(const char *name,uid_t uid,gid_t gid);

#define setegid(g) amiga_setegid(g)
int amiga_setegid(gid_t g);

#define seteuid(u) amiga_seteuid(u)
int amiga_seteuid(uid_t u);

#define gettimeofday(tv) amiga_gettimeofday(tv)
int amiga_gettimeofday(struct timeval *tv);

#define utime(name,time) amiga_utime(name,time)
int amiga_utime(const char *name,const struct utimbuf *time);

#define sleep(seconds) amiga_sleep(seconds)
void amiga_sleep(unsigned int seconds);

#define crypt(key,salt) amiga_crypt(key,salt)
char * amiga_crypt(const char *key,const char *salt);

#define getpass(prompt) amiga_getpass(prompt)
char * amiga_getpass(const char *prompt);

#define setgid(id) amiga_setgid(id)
int amiga_setgid(gid_t id);

#define setgroups(ngroups,groups) amiga_setgroups(ngroups,groups)
int amiga_setgroups(int ngroups,const gid_t *groups);

#define getgid() amiga_getgid()
gid_t amiga_getgid(void);

#define getgrgid(gid) amiga_getgrgid(gid)
struct group * amiga_getgrgid(gid_t gid);

#define getgrnam(name) amiga_getgrnam(name)
struct group * getgrnam(const char * name);

#define getgroups(ngroups,groups) amiga_getgroups(ngroups,groups)
int amiga_getgroups(int ngroups, gid_t *groups);

#define gethostbyaddr(addr,len,type) amiga_gethostbyaddr(addr,len,type)
struct hostent * amiga_gethostbyaddr(const char *addr, int len, int type);

#define getnetbyname(name) amiga_getnetbyname(name)
struct netent * amiga_getnetbyname(const char *name);

#define gethostbyname(name) amiga_gethostbyname(name)
struct hostent * amiga_gethostbyname(const char *name);

#define gethostname(hostname,size) amiga_gethostname(hostname,size)
int amiga_gethostname(char *hostname,int size);

#define getpid() amiga_getpid()
int amiga_getpid(void);

#define getpwnam(name) amiga_getpwnam(name)
struct passwd * amiga_getpwnam(const char *name);

#define getpwuid(uid) amiga_getpwuid(uid)
struct passwd * amiga_getpwuid(uid_t uid);

#define getuid() amiga_getuid()
uid_t amiga_getuid(void);

#define initgroups(name,basegroup) amiga_initgroups(name,basegroup)
int amiga_initgroups(const char *name, gid_t basegroup);

#define setuid(id) amiga_setuid(id)
int amiga_setuid(uid_t id);

#define umask(mask) amiga_umask(mask)
mode_t amiga_umask(mode_t mask);

#define inet_addr(addr) amiga_inet_addr(addr)
unsigned long amiga_inet_addr(const char *addr);

#define inet_ntoa(addr) amiga_inet_ntoa(addr)
char * amiga_inet_ntoa(struct in_addr in);

#define getopt(argc,argv,opts) amiga_getopt(argc,argv,opts)
int amiga_getopt(int argc, char * argv[], char *opts);

#define getegid() amiga_getegid()
gid_t amiga_getegid(void);

#define geteuid() amiga_geteuid()
uid_t amiga_geteuid(void);

#define system(cmd) amiga_system(cmd)
int amiga_system(const char *cmd);

#define opendir(dirName) amiga_opendir(dirName)
void * amiga_opendir(const char *dirName);

#define closedir(dir) amiga_closedir(dir)
void amiga_closedir(DIR *dir);

#define readdir(dir) amiga_readdir(dir)
struct dirent *amiga_readdir(DIR *dir);

#define fork() amiga_fork()
int amiga_fork(void);

#define kill(pid,sig) amiga_kill(pid,sig)
int amiga_kill(int pid,int sig);

#define alarm(seconds) amiga_alarm(seconds)
void amiga_alarm(int seconds);

#define strcasecmp(a,b) amiga_strcasecmp(a,b)
int amiga_strcasecmp(const char *a,const char *b);

#define strncasecmp(a,b,len) amiga_strncasecmp(a,b,len)
int amiga_strncasecmp(const char *a,const char *b,int len);

#define setregid(real,eff) amiga_setregid(real,eff)
int amiga_setregid(gid_t real, gid_t eff);

#define setsid() amiga_setsid()
long amiga_setsid(void);

#define setreuid(real, eff) amiga_setreuid(real, eff)
int amiga_setreuid(uid_t real, uid_t eff);

#define getsockname(sockfd,name,namelen) amiga_getsockname(sockfd,name,namelen)
int amiga_getsockname(int sockfd, struct sockaddr *name, int *namelen);

#define execl(path,arg,arg2,arg3) amiga_execl(path,arg,arg2,arg3)
int amiga_execl(const char *path,const char *arg,...);

#define strerror(error) amiga_strerror(error)
char * amiga_strerror(int error);

#define access(name,modes) amiga_access(name,modes)
int amiga_access(const char *name,int modes);

#define lseek(fd,offset,mode) amiga_lseek(fd,offset,mode)
off_t amiga_lseek(int fd,off_t offset,int mode);

#define chroot(name) amiga_chroot(name)
int amiga_chroot(const char *name);

#define sigmask(num) amiga_sigmask(num)
int amiga_sigmask(int num);

#define sigblock(mask) amiga_sigblock(mask)
int amiga_sigblock(int mask);

#define sigsetmask(mask) amiga_sigsetmask(mask)
int amiga_sigsetmask(int sigmask);

/* This is not an emulated function. */
void amiga_yield_fd(int fd);

#define statfs(path,fsd) amiga_statfs(path,fsd)
int amiga_statfs(const char *path,struct statfs *fsd);

#define fcntl(fd,cmd,arg) amiga_fcntl(fd,cmd,arg)
int amiga_fcntl(int fd,int cmd,unsigned long arg);

#define signal(which,action) amiga_signal(which,action)
void (*amiga_signal(int,void (*)(int)))(int);

#define waitpid(pid,status,options) amiga_waitpid(pid,status,options)
int amiga_waitpid(pid_t pid,int *status,int options);

#define getc(in) amiga_fgetc(in)
#define fgetc(in) amiga_fgetc(in)
int amiga_fgetc(FILE *in);

#define fgets(str,n,in) amiga_fgets(str,n,in)
char * amiga_fgets(char *str,int n,FILE * in);

#define fputs(str,out) amiga_fputs(str,out)
int amiga_fputs(const char *str,FILE *out);

#define puts(str) amiga_puts(str)
int amiga_puts(const char *str);

#define vfprintf(out,fmt,args) amiga_vfprintf(out,fmt,args)
int amiga_vfprintf(FILE *out,const char *fmt,va_list args);

#define fprintf amiga_fprintf
int amiga_fprintf(FILE *out,const char *fmt,...);

#define printf amiga_printf
int amiga_printf(const char *fmt,...);

#define fwrite(data,blockSize,numBlocks,out) amiga_fwrite(data,blockSize,numBlocks,out)
size_t amiga_fwrite(const void *data,size_t blockSize,size_t numBlocks,FILE *out);

#define fread(data,blockSize,numBlocks,in) amiga_fread(data,blockSize,numBlocks,in)
size_t amiga_fread(void *data,size_t blockSize,size_t numBlocks,FILE *in);

#define fclose(stream) amiga_fclose(stream)
int amiga_fclose(FILE * stream);

#define fflush(stream) amiga_fflush(stream)
int amiga_fflush(FILE * stream);

#define fseek(stream,offset,mode) amiga_fseek(stream,offset,mode)
int amiga_fseek(FILE * stream,long int offset,int mode);

#define ftell(stream) amiga_ftell(stream)
long int amiga_ftell(FILE * stream);

#define setvbuf(stream,buff,type,size) amiga_setvbuf(stream,buff,type,size)
int amiga_setvbuf(FILE *stream,char *buff,int type,size_t size);

#define rewind(p) amiga_fseek(p, 0L, 0)

#define putchar(c) amiga_fputc(c,stdout)
#define putc(c) amiga_fputc(c,stdout)
#define fputc(c,stream) amiga_fputc(c,stream)
int amiga_fputc(int c,FILE *stream);

#define setbuf(stream,buffer) amiga_setbuf(stream,buffer)
void amiga_setbuf(FILE *stream,char *buffer);

#define recv(fd,buff,nbytes,flags) amiga_recv(fd,buff,nbytes,flags)
int amiga_recv(int fd,void *buff,size_t nbytes,int flags);

#define send(fd,buff,nbytes,flags) amiga_send(fd,buff,nbytes,flags)
int amiga_send(int fd,void *buff,size_t nbytes,int flags);

int amiga_smbrun(char *cmd,char *outfile,BOOL shared);

int amiga_get_interfaces(struct iface_struct * ifaces,int max_interfaces);

FILE * amiga_popen(const char * command,const char * mode);

int amiga_pclose(FILE * fp);